Field of the Invention
The present invention generally relates to software development, and more particularly to a method of providing image content which may be used as an icon during new software implementation.
Description of the Related Art
Modern computer users are familiar with icons and other interactive objects used in various computer programs such as operating systems and software applications. Many icons are used in the same or similar visual form by different programs to initiate the same basic routines. For example, an icon having a pair of scissors is often used as a “cut” command, i.e., removing content from a file or input field location and placing it in a temporary location (e.g., a “clipboard”) from which the content can subsequently be copied into another file or location. Icons are frequently co-located in a menu, toolbar or ribbon of an application, but can appear anywhere within a graphical user interface, with or without accompanying text.
The number and nature of these icons is virtually limitless; one collection of commonly used icons may be found at internet address www.ibm.com/design/language/resources/icon-library. That library categorizes the icons into action-based, object-based, formatting, and glyphs, but these designations are not exclusive. Other icon libraries are publically available including some that are text-searchable. The Noun Project (internet address thenounproject.com) allows users to directly import a link for an icon into certain applications by dragging-and-dropping the icon from a web browser. While icons essentially represent an image, they may be considered in the context of a computer system without reference to graphical features, e.g., by manipulating the file or other computer-readable data which is representative of the visual image without actually displaying that image. Pure text without graphical elements may also be considered an icon in certain circumstances. Icons can be stored in a common file or as unitary files in a variety of formats including scalable vector graphics (SVG), portable network graphics (PNG), joint photographic experts group (JPG), or Microsoft icon format (ICO).
When designers create new computer programs, they often want to use icon images that are already known or are otherwise in use for actions or objects that may have a universal meaning. They can delve into icon libraries or repositories to locate familiar icons. Icons may also be retrieved in other manners, such as from sprite sheets. A sprite sheet is basically a single file or image which contains a set of multiple smaller images, usually laid out in a tile pattern. Sprites allow graphical objects such as icons to be handled separately from the memory bitmap of a video display, simplifying the rendering process. Most computer files have specific icons associated with them, often embedded, particularly with executable files (EXE files), library files such as dynamic link libraries (DLLs), and display objects such as animated cursor files. Some of these icons may be hidden, i.e., they do not show up from a normal display of the file or object, but they can be revealed using an icon extraction tool or via appropriate coding in an application. Designers can also craft their own image libraries for custom icons. The custom icons can be created from scratch or converted from some other source and imported.
A designer can copy an icon from one of these existing sources into a mockup of a graphical user interface for a proposed new software package, or may simply sketch a representation of the icon according to the designer's recollection or whim and import this sketch into the mockup. The mockup may not actually contain the icon as a separate object, e.g., the mockup might be a bitmap screenshot or even a scan of a hardcopy printout. When the proposed design is handed off to the development team to implement the code for the program, the developer becomes responsible for obtaining the correct or appropriate icon image and associating it with the object indicated in the mockup in order to carry out the designer's intent.